package com.ruoyi.system.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.SpffCommentsMapper;
import com.ruoyi.system.domain.SpffComments;
import com.ruoyi.system.service.ISpffCommentsService;

/**
 * 评论Service业务层处理
 * 
 * @author xjj
 * @date 2025-09-11
 */
@Service
public class SpffCommentsServiceImpl implements ISpffCommentsService 
{
    @Autowired
    private SpffCommentsMapper spffCommentsMapper;

    /**
     * 查询评论
     * 
     * @param id 评论主键
     * @return 评论
     */
    @Override
    public SpffComments selectSpffCommentsById(Long id)
    {
        return spffCommentsMapper.selectSpffCommentsById(id);
    }

    /**
     * 查询评论列表
     * 
     * @param spffComments 评论
     * @return 评论
     */
    @Override
    public List<SpffComments> selectSpffCommentsList(SpffComments spffComments)
    {
        return spffCommentsMapper.selectSpffCommentsList(spffComments);
    }

    /**
     * 新增评论
     * 
     * @param spffComments 评论
     * @return 结果
     */
    @Override
    public int insertSpffComments(SpffComments spffComments)
    {
        return spffCommentsMapper.insertSpffComments(spffComments);
    }

    /**
     * 修改评论
     * 
     * @param spffComments 评论
     * @return 结果
     */
    @Override
    public int updateSpffComments(SpffComments spffComments)
    {
        return spffCommentsMapper.updateSpffComments(spffComments);
    }

    /**
     * 批量删除评论
     * 
     * @param ids 需要删除的评论主键
     * @return 结果
     */
    @Override
    public int deleteSpffCommentsByIds(Long[] ids)
    {
        return spffCommentsMapper.deleteSpffCommentsByIds(ids);
    }

    /**
     * 删除评论信息
     * 
     * @param id 评论主键
     * @return 结果
     */
    @Override
    public int deleteSpffCommentsById(Long id)
    {
        return spffCommentsMapper.deleteSpffCommentsById(id);
    }

    /**
     * 根据父评论ID获取子评论列表
     * 
     * @param parentId 父评论ID
     * @return 子评论列表
     */
    @Override
    public List<SpffComments> selectRepliesByParentId(Long parentId)
    {
        return spffCommentsMapper.selectRepliesByParentId(parentId);
    }

    /**
     * 增加评论回复数
     * 
     * @param commentId 评论ID
     * @return 结果
     */
    @Override
    public int incrementReplyCount(Long commentId)
    {
        return spffCommentsMapper.incrementReplyCount(commentId);
    }

    /**
     * 减少评论回复数
     * 
     * @param commentId 评论ID
     * @return 结果
     */
    @Override
    public int decrementReplyCount(Long commentId)
    {
        return spffCommentsMapper.decrementReplyCount(commentId);
    }

    /**
     * 切换评论点赞状态
     * 
     * @param commentId 评论ID
     * @param userId 用户ID
     * @return 结果（1-点赞，0-取消点赞）
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int toggleCommentLike(Long commentId, Long userId)
    {
        String likeSetKey = "comment_like:" + commentId;
        String userIdStr = userId.toString();
        
        // 注入RedisCache
        com.ruoyi.common.core.redis.RedisCache redisCache = 
            com.ruoyi.common.utils.spring.SpringUtils.getBean(com.ruoyi.common.core.redis.RedisCache.class);
        
        @SuppressWarnings("unchecked")
        org.springframework.data.redis.core.SetOperations<String, String> setOps = 
            (org.springframework.data.redis.core.SetOperations<String, String>) redisCache.redisTemplate.opsForSet();
        
        Boolean isMemberResult = setOps.isMember(likeSetKey, userIdStr);
        boolean isLiked = isMemberResult != null && isMemberResult;
        
        try {
            if (isLiked) {
                // 取消点赞
                int dbResult = spffCommentsMapper.decrementLikeCount(commentId);
                if (dbResult > 0) {
                    setOps.remove(likeSetKey, userIdStr);
                    return 0; // 取消点赞
                } else {
                    throw new RuntimeException("数据库更新失败");
                }
            } else {
                // 点赞
                int dbResult = spffCommentsMapper.incrementLikeCount(commentId);
                if (dbResult > 0) {
                    setOps.add(likeSetKey, userIdStr);
                    return 1; // 点赞成功
                } else {
                    throw new RuntimeException("数据库更新失败");
                }
            }
        } catch (Exception e) {
            throw e; // 让事务回滚
        }
    }

    /**
     * 检查用户是否已点赞评论
     * 
     * @param commentId 评论ID
     * @param userId 用户ID
     * @return 是否已点赞
     */
    @Override
    public boolean isUserLikedComment(Long commentId, Long userId)
    {
        String likeSetKey = "comment_like:" + commentId;
        String userIdStr = userId.toString();
        
        com.ruoyi.common.core.redis.RedisCache redisCache = 
            com.ruoyi.common.utils.spring.SpringUtils.getBean(com.ruoyi.common.core.redis.RedisCache.class);
        
        @SuppressWarnings("unchecked")
        org.springframework.data.redis.core.SetOperations<String, String> setOps = 
            (org.springframework.data.redis.core.SetOperations<String, String>) redisCache.redisTemplate.opsForSet();
        
        Boolean isMemberResult = setOps.isMember(likeSetKey, userIdStr);
        return isMemberResult != null && isMemberResult;
    }

    /**
     * 增加评论点赞数
     * 
     * @param commentId 评论ID
     * @return 结果
     */
    @Override
    public int incrementLikeCount(Long commentId)
    {
        return spffCommentsMapper.incrementLikeCount(commentId);
    }

    /**
     * 减少评论点赞数
     * 
     * @param commentId 评论ID
     * @return 结果
     */
    @Override
    public int decrementLikeCount(Long commentId)
    {
        return spffCommentsMapper.decrementLikeCount(commentId);
    }

    // ======== 评论管理相关方法实现 ========

    /**
     * 查询评论列表（包含层级结构）
     * 
     * @param spffComments 评论查询条件
     * @return 评论集合
     */
    @Override
    public List<SpffComments> selectSpffCommentsListWithHierarchy(SpffComments spffComments)
    {
        // 获取所有评论数据
        List<SpffComments> allComments = spffCommentsMapper.selectSpffCommentsListWithHierarchy(spffComments);
        
        // 构建层级结构
        return buildHierarchyComments(allComments);
    }

    /**
     * 构建评论层级结构
     * 
     * @param comments 扁平评论列表
     * @return 层级结构评论列表
     */
    private List<SpffComments> buildHierarchyComments(List<SpffComments> comments) {
        if (comments == null || comments.isEmpty()) {
            return new java.util.ArrayList<>();
        }
        
        // 使用Map存储评论，便于查找
        java.util.Map<Long, SpffComments> commentMap = new java.util.HashMap<>();
        java.util.List<SpffComments> rootComments = new java.util.ArrayList<>();
        
        // 初始化replies列表
        for (SpffComments comment : comments) {
            comment.setReplies(new java.util.ArrayList<>());
            commentMap.put(comment.getId(), comment);
        }
        
        // 构建层级关系
        for (SpffComments comment : comments) {
            if (comment.getParentId() == null || comment.getParentId() == 0) {
                // 一级评论
                rootComments.add(comment);
            } else {
                // 二级评论，找到父评论并添加到replies中
                SpffComments parent = commentMap.get(comment.getParentId());
                if (parent != null) {
                    parent.getReplies().add(comment);
                }
            }
        }
        
        return rootComments;
    }

    /**
     * 查询评论列表（排除被屏蔽的用户评论）
     * 
     * @param spffComments 评论查询条件
     * @return 评论集合
     */
    @Override
    public List<SpffComments> selectSpffCommentsListWithBlacklist(SpffComments spffComments)
    {
        return spffCommentsMapper.selectSpffCommentsListWithBlacklist(spffComments);
    }

    /**
     * 屏蔽用户的所有评论
     * 
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int blockUserComments(Long userId)
    {
        return spffCommentsMapper.blockUserComments(userId);
    }

    /**
     * 取消屏蔽用户的所有评论
     * 
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int unblockUserComments(Long userId)
    {
        return spffCommentsMapper.unblockUserComments(userId);
    }

    /**
     * 屏蔽单条评论（如果是一级评论，同时屏蔽其所有子评论）
     * 
     * @param commentId 评论ID
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int blockComment(Long commentId)
    {
        // 先查询评论信息
        SpffComments comment = spffCommentsMapper.selectSpffCommentsById(commentId);
        if (comment == null) {
            return 0;
        }

        // 屏蔽当前评论
        comment.setStatus(0);
        int result = spffCommentsMapper.updateSpffComments(comment);

        // 如果是一级评论（parentId = 0），则屏蔽所有子评论
        if (comment.getParentId() != null && comment.getParentId() == 0) {
            spffCommentsMapper.blockRepliesByParentId(commentId);
        }

        return result;
    }

    /**
     * 取消屏蔽单条评论（如果是一级评论，同时取消屏蔽其所有子评论）
     * 
     * @param commentId 评论ID
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int unblockComment(Long commentId)
    {
        // 先查询评论信息
        SpffComments comment = spffCommentsMapper.selectSpffCommentsById(commentId);
        if (comment == null) {
            return 0;
        }

        // 取消屏蔽当前评论
        comment.setStatus(1);
        int result = spffCommentsMapper.updateSpffComments(comment);

        // 如果是一级评论（parentId = 0），则取消屏蔽所有子评论
        if (comment.getParentId() != null && comment.getParentId() == 0) {
            spffCommentsMapper.unblockRepliesByParentId(commentId);
        }

        return result;
    }

    /**
     * 批量屏蔽评论
     * 
     * @param commentIds 评论ID数组
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int batchBlockComments(Long[] commentIds)
    {
        int result = 0;
        for (Long commentId : commentIds) {
            result += blockComment(commentId);
        }
        return result;
    }

    /**
     * 批量启用评论
     * 
     * @param commentIds 评论ID数组
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int batchEnableComments(Long[] commentIds)
    {
        int result = 0;
        for (Long commentId : commentIds) {
            result += unblockComment(commentId);
        }
        return result;
    }

    /**
     * 批量删除评论
     * 
     * @param commentIds 评论ID数组
     * @return 结果
     */
    @Override
    @org.springframework.transaction.annotation.Transactional
    public int batchDeleteComments(Long[] commentIds)
    {
        return spffCommentsMapper.deleteSpffCommentsByIds(commentIds);
    }

    /**
     * 根据用户昵称搜索评论
     * 
     * @param spffComments 评论查询条件（包含昵称）
     * @return 评论集合
     */
    @Override
    public List<SpffComments> searchCommentsByNickname(SpffComments spffComments)
    {
        return spffCommentsMapper.searchCommentsByNickname(spffComments);
    }
}
